home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex0 < prev    next >
Encoding:
Text File  |  1990-06-08  |  46.7 KB  |  2,337 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. println () {
  5.     println_regmem 
  6.   switch ( selector ) 
  7.   {case 19 : 
  8.     {
  9.       (void) putc('\n',  stdout );
  10.       (void) putc('\n',  logfile );
  11.       termoffset = 0 ; 
  12.       fileoffset = 0 ; 
  13.     } 
  14.     break ; 
  15.   case 18 : 
  16.     {
  17.       (void) putc('\n',  logfile );
  18.       fileoffset = 0 ; 
  19.     } 
  20.     break ; 
  21.   case 17 : 
  22.     {
  23.       (void) putc('\n',  stdout );
  24.       termoffset = 0 ; 
  25.     } 
  26.     break ; 
  27.   case 16 : 
  28.   case 20 : 
  29.   case 21 : 
  30.     ; 
  31.     break ; 
  32.     default: 
  33.     (void) putc('\n',  writefile [ selector ] );
  34.     break ; 
  35.   } 
  36. } 
  37. zprintchar ( s ) 
  38. ASCIIcode s ; 
  39. {/* 10 */ printchar_regmem 
  40.   if ( s == eqtb [ 5316 ] .cint ) 
  41.   if ( selector < 20 ) 
  42.   {
  43.     println () ; 
  44.     return ; 
  45.   } 
  46.   switch ( selector ) 
  47.   {case 19 : 
  48.     {
  49.       (void) putc( Xchr ( s ) ,  stdout );
  50.       (void) putc( Xchr ( s ) ,  logfile );
  51.       incr ( termoffset ) ; 
  52.       incr ( fileoffset ) ; 
  53.       if ( termoffset == maxprintline ) 
  54.       {
  55.     (void) putc('\n',  stdout );
  56.     termoffset = 0 ; 
  57.       } 
  58.       if ( fileoffset == maxprintline ) 
  59.       {
  60.     (void) putc('\n',  logfile );
  61.     fileoffset = 0 ; 
  62.       } 
  63.     } 
  64.     break ; 
  65.   case 18 : 
  66.     {
  67.       (void) putc( Xchr ( s ) ,  logfile );
  68.       incr ( fileoffset ) ; 
  69.       if ( fileoffset == maxprintline ) 
  70.       println () ; 
  71.     } 
  72.     break ; 
  73.   case 17 : 
  74.     {
  75.       (void) putc( Xchr ( s ) ,  stdout );
  76.       incr ( termoffset ) ; 
  77.       if ( termoffset == maxprintline ) 
  78.       println () ; 
  79.     } 
  80.     break ; 
  81.   case 16 : 
  82.     ; 
  83.     break ; 
  84.   case 20 : 
  85.     if ( tally < trickcount ) 
  86.     trickbuf [ tally % errorline ] = s ; 
  87.     break ; 
  88.   case 21 : 
  89.     {
  90.       if ( poolptr < poolsize ) 
  91.       {
  92.     strpool [ poolptr ] = s ; 
  93.     incr ( poolptr ) ; 
  94.       } 
  95.     } 
  96.     break ; 
  97.     default: 
  98.     (void) putc( Xchr ( s ) ,  writefile [ selector ] );
  99.     break ; 
  100.   } 
  101.   incr ( tally ) ; 
  102. } 
  103. zprint ( s ) 
  104. integer s ; 
  105. {/* 10 */ print_regmem 
  106.   poolpointer j  ; 
  107.   if ( s >= strptr ) 
  108.   s = 130 ; 
  109.   else if ( s < 128 ) 
  110.   if ( s < 0 ) 
  111.   s = 130 ; 
  112.   else if ( ( s == eqtb [ 5316 ] .cint ) ) 
  113.   if ( selector < 20 ) 
  114.   {
  115.     println () ; 
  116.     return ; 
  117.   } 
  118.   j = strstart [ s ] ; 
  119.   while ( j < strstart [ s + 1 ] ) {
  120.       
  121.     printchar ( strpool [ j ] ) ; 
  122.     incr ( j ) ; 
  123.   } 
  124. } 
  125. zslowprint ( s ) 
  126. integer s ; 
  127. {/* 10 */ slowprint_regmem 
  128.   poolpointer j  ; 
  129.   if ( s >= strptr ) 
  130.   s = 130 ; 
  131.   else if ( s < 128 ) 
  132.   if ( s < 0 ) 
  133.   s = 130 ; 
  134.   else if ( ( s == eqtb [ 5316 ] .cint ) ) 
  135.   if ( selector < 20 ) 
  136.   {
  137.     println () ; 
  138.     return ; 
  139.   } 
  140.   j = strstart [ s ] ; 
  141.   while ( j < strstart [ s + 1 ] ) {
  142.       
  143.     print ( strpool [ j ] ) ; 
  144.     incr ( j ) ; 
  145.   } 
  146. } 
  147. zprintnl ( s ) 
  148. strnumber s ; 
  149. {printnl_regmem 
  150.   if ( ( ( termoffset > 0 ) && ( odd ( selector ) ) ) || ( ( fileoffset > 0 ) 
  151.   && ( selector >= 18 ) ) ) 
  152.   println () ; 
  153.   print ( s ) ; 
  154. } 
  155. zprintesc ( s ) 
  156. strnumber s ; 
  157. {printesc_regmem 
  158.   integer c  ; 
  159.   c = eqtb [ 5312 ] .cint ; 
  160.   if ( c >= 0 ) 
  161.   if ( c < 128 ) 
  162.   print ( c ) ; 
  163.   print ( s ) ; 
  164. } 
  165. zprintthedigs ( k ) 
  166. eightbits k ; 
  167. {printthedigs_regmem 
  168.   while ( k > 0 ) {
  169.       
  170.     decr ( k ) ; 
  171.     if ( dig [ k ] < 10 ) 
  172.     printchar ( 48 + dig [ k ] ) ; 
  173.     else printchar ( 55 + dig [ k ] ) ; 
  174.   } 
  175. } 
  176. zprintint ( n ) 
  177. integer n ; 
  178. {printint_regmem 
  179.   schar k  ; 
  180.   integer m  ; 
  181.   k = 0 ; 
  182.   if ( n < 0 ) 
  183.   {
  184.     printchar ( 45 ) ; 
  185.     if ( n > -100000000L ) 
  186.     n = - (integer) n ; 
  187.     else {
  188.     
  189.       m = -1 - n ; 
  190.       n = m / 10 ; 
  191.       m = ( m % 10 ) + 1 ; 
  192.       k = 1 ; 
  193.       if ( m < 10 ) 
  194.       dig [ 0 ] = m ; 
  195.       else {
  196.       
  197.     dig [ 0 ] = 0 ; 
  198.     incr ( n ) ; 
  199.       } 
  200.     } 
  201.   } 
  202.   do {
  203.       dig [ k ] = n % 10 ; 
  204.     n = n / 10 ; 
  205.     incr ( k ) ; 
  206.   } while ( ! ( n == 0 ) ) ; 
  207.   printthedigs ( k ) ; 
  208. } 
  209. zprintcs ( p ) 
  210. integer p ; 
  211. {printcs_regmem 
  212.   if ( p < 258 ) 
  213.   if ( p >= 129 ) 
  214.   if ( p == 257 ) 
  215.   {
  216.     printesc ( 363 ) ; 
  217.     printesc ( 364 ) ; 
  218.   } 
  219.   else {
  220.       
  221.     printesc ( p - 129 ) ; 
  222.     if ( eqtb [ 4627 + p - 129 ] .hh .v.RH == 11 ) 
  223.     printchar ( 32 ) ; 
  224.   } 
  225.   else if ( p < 1 ) 
  226.   printesc ( 365 ) ; 
  227.   else print ( p - 1 ) ; 
  228.   else if ( p >= 3525 ) 
  229.   printesc ( 365 ) ; 
  230.   else if ( ( hash [ p ] .v.RH >= strptr ) ) 
  231.   printesc ( 366 ) ; 
  232.   else {
  233.       
  234.     printesc ( 206 ) ; 
  235.     slowprint ( hash [ p ] .v.RH ) ; 
  236.     printchar ( 32 ) ; 
  237.   } 
  238. } 
  239. zsprintcs ( p ) 
  240. halfword p ; 
  241. {sprintcs_regmem 
  242.   if ( p < 258 ) 
  243.   if ( p < 129 ) 
  244.   print ( p - 1 ) ; 
  245.   else if ( p < 257 ) 
  246.   printesc ( p - 129 ) ; 
  247.   else {
  248.       
  249.     printesc ( 363 ) ; 
  250.     printesc ( 364 ) ; 
  251.   } 
  252.   else {
  253.       
  254.     printesc ( 206 ) ; 
  255.     slowprint ( hash [ p ] .v.RH ) ; 
  256.   } 
  257. } 
  258. zprintfilename ( n , a , e ) 
  259. integer n , a , e ; 
  260. {printfilename_regmem 
  261.   print ( a ) ; 
  262.   print ( n ) ; 
  263.   print ( e ) ; 
  264. } 
  265. zprintsize ( s ) 
  266. integer s ; 
  267. {printsize_regmem 
  268.   if ( s == 0 ) 
  269.   printesc ( 277 ) ; 
  270.   else if ( s == 16 ) 
  271.   printesc ( 278 ) ; 
  272.   else printesc ( 279 ) ; 
  273. } 
  274. zprintwritewhatsit ( s , p ) 
  275. strnumber s ; 
  276. halfword p ; 
  277. {printwritewhatsit_regmem 
  278.   printesc ( s ) ; 
  279.   if ( mem [ p + 1 ] .hh .v.LH < 16 ) 
  280.   printint ( mem [ p + 1 ] .hh .v.LH ) ; 
  281.   else if ( mem [ p + 1 ] .hh .v.LH == 16 ) 
  282.   printchar ( 42 ) ; 
  283.   else printchar ( 45 ) ; 
  284. } 
  285. #ifdef DEBUG
  286. #endif /* DEBUG */
  287. jumpout () {
  288.     jumpout_regmem 
  289.   closefilesandtermina () ; 
  290.   {
  291.     termflush ( stdout ) ; 
  292.     readyalready = 0 ; 
  293.     if ( ( history != 0 ) && ( history != 1 ) ) {
  294.       uexit ( 1 ) ; 
  295.     } else {
  296.       uexit ( 0 ) ; 
  297.     }
  298.   } 
  299. } 
  300. error () {
  301.     /* 22 10 */ error_regmem 
  302.   ASCIIcode c  ; 
  303.   integer s1, s2, s3, s4  ; 
  304.   if ( history < 2 ) 
  305.   history = 2 ; 
  306.   printchar ( 46 ) ; 
  307.   showcontext () ; 
  308.   if ( interaction == 3 ) 
  309.   while ( true ) {
  310.       
  311.     lab22: clearforerrorprompt () ; 
  312.     {
  313.       wakeupterminal () ; 
  314.       print ( 135 ) ; 
  315.       terminput () ; 
  316.     } 
  317.     if ( last == first ) 
  318.     return ; 
  319.     c = buffer [ first ] ; 
  320.     if ( c >= 97 ) 
  321.     c = c - 32 ; 
  322.     switch ( c ) 
  323.     {case 48 : 
  324.     case 49 : 
  325.     case 50 : 
  326.     case 51 : 
  327.     case 52 : 
  328.     case 53 : 
  329.     case 54 : 
  330.     case 55 : 
  331.     case 56 : 
  332.     case 57 : 
  333.       if ( deletionsallowed ) 
  334.       {
  335.     s1 = curtok ; 
  336.     s2 = curcmd ; 
  337.     s3 = curchr ; 
  338.     s4 = alignstate ; 
  339.     alignstate = 1000000L ; 
  340.     OKtointerrupt = false ; 
  341.     if ( ( last > first + 1 ) && ( buffer [ first + 1 ] >= 48 ) && ( 
  342.     buffer [ first + 1 ] <= 57 ) ) 
  343.     c = c * 10 + buffer [ first + 1 ] - 48 * 11 ; 
  344.     else c = c - 48 ; 
  345.     while ( c > 0 ) {
  346.         
  347.       gettoken () ; 
  348.       decr ( c ) ; 
  349.     } 
  350.     curtok = s1 ; 
  351.     curcmd = s2 ; 
  352.     curchr = s3 ; 
  353.     alignstate = s4 ; 
  354.     OKtointerrupt = true ; 
  355.     {
  356.       helpptr = 2 ; 
  357.       helpline [ 1 ] = 148 ; 
  358.       helpline [ 0 ] = 149 ; 
  359.     } 
  360.     showcontext () ; 
  361.     goto lab22 ; 
  362.       } 
  363.       break ; 
  364.     ;
  365. #ifdef DEBUG
  366.     case 68 : 
  367.       {
  368.     debughelp () ; 
  369.     goto lab22 ; 
  370.       } 
  371.       break ; 
  372. #endif /* DEBUG */
  373.     case 69 : 
  374.       if ( baseptr > 0 ) 
  375.       {
  376.     editnamestart = strstart [ inputstack [ baseptr ] .namefield ] ; 
  377.     editnamelength = strstart [ inputstack [ baseptr ] .namefield + 1 ] - 
  378.     strstart [ inputstack [ baseptr ] .namefield ] ; 
  379.     editline = line ; 
  380.     jumpout () ; 
  381.       } 
  382.       break ; 
  383.     case 72 : 
  384.       {
  385.     if ( useerrhelp ) 
  386.     {
  387.       giveerrhelp () ; 
  388.       useerrhelp = false ; 
  389.     } 
  390.     else {
  391.         
  392.       if ( helpptr == 0 ) 
  393.       {
  394.         helpptr = 2 ; 
  395.         helpline [ 1 ] = 150 ; 
  396.         helpline [ 0 ] = 151 ; 
  397.       } 
  398.       do {
  399.           decr ( helpptr ) ; 
  400.         print ( helpline [ helpptr ] ) ; 
  401.         println () ; 
  402.       } while ( ! ( helpptr == 0 ) ) ; 
  403.     } 
  404.     {
  405.       helpptr = 4 ; 
  406.       helpline [ 3 ] = 152 ; 
  407.       helpline [ 2 ] = 151 ; 
  408.       helpline [ 1 ] = 153 ; 
  409.       helpline [ 0 ] = 154 ; 
  410.     } 
  411.     goto lab22 ; 
  412.       } 
  413.       break ; 
  414.     case 73 : 
  415.       {
  416.     beginfilereading () ; 
  417.     if ( last > first + 1 ) 
  418.     {
  419.       curinput .locfield = first + 1 ; 
  420.       buffer [ first ] = 32 ; 
  421.     } 
  422.     else {
  423.         
  424.       {
  425.         wakeupterminal () ; 
  426.         print ( 147 ) ; 
  427.         terminput () ; 
  428.       } 
  429.       curinput .locfield = first ; 
  430.     } 
  431.     first = last ; 
  432.     curinput .limitfield = last - 1 ; 
  433.     return ; 
  434.       } 
  435.       break ; 
  436.     case 81 : 
  437.     case 82 : 
  438.     case 83 : 
  439.       {
  440.     errorcount = 0 ; 
  441.     interaction = 0 + c - 81 ; 
  442.     print ( 142 ) ; 
  443.     switch ( c ) 
  444.     {case 81 : 
  445.       {
  446.         printesc ( 143 ) ; 
  447.         decr ( selector ) ; 
  448.       } 
  449.       break ; 
  450.     case 82 : 
  451.       printesc ( 144 ) ; 
  452.       break ; 
  453.     case 83 : 
  454.       printesc ( 145 ) ; 
  455.       break ; 
  456.     } 
  457.     print ( 146 ) ; 
  458.     println () ; 
  459.     termflush ( stdout ) ; 
  460.     return ; 
  461.       } 
  462.       break ; 
  463.     case 88 : 
  464.       {
  465.     interaction = 2 ; 
  466.     jumpout () ; 
  467.       } 
  468.       break ; 
  469.       default: 
  470.       ; 
  471.       break ; 
  472.     } 
  473.     {
  474.       print ( 136 ) ; 
  475.       printnl ( 137 ) ; 
  476.       printnl ( 138 ) ; 
  477.       if ( baseptr > 0 ) 
  478.       print ( 139 ) ; 
  479.       if ( deletionsallowed ) 
  480.       printnl ( 140 ) ; 
  481.       printnl ( 141 ) ; 
  482.     } 
  483.   } 
  484.   incr ( errorcount ) ; 
  485.   if ( errorcount == 100 ) 
  486.   {
  487.     printnl ( 134 ) ; 
  488.     history = 3 ; 
  489.     jumpout () ; 
  490.   } 
  491.   if ( interaction > 0 ) 
  492.   decr ( selector ) ; 
  493.   if ( useerrhelp ) 
  494.   {
  495.     println () ; 
  496.     giveerrhelp () ; 
  497.   } 
  498.   else while ( helpptr > 0 ) {
  499.       
  500.     decr ( helpptr ) ; 
  501.     printnl ( helpline [ helpptr ] ) ; 
  502.   } 
  503.   println () ; 
  504.   if ( interaction > 0 ) 
  505.   incr ( selector ) ; 
  506.   println () ; 
  507. } 
  508. zfatalerror ( s ) 
  509. strnumber s ; 
  510. {fatalerror_regmem 
  511.   normalizeselector () ; 
  512.   {
  513.     if ( interaction == 3 ) 
  514.     wakeupterminal () ; 
  515.     printnl ( 133 ) ; 
  516.     print ( 156 ) ; 
  517.   } 
  518.   {
  519.     helpptr = 1 ; 
  520.     helpline [ 0 ] = s ; 
  521.   } 
  522.   {
  523.     if ( interaction == 3 ) 
  524.     interaction = 2 ; 
  525.     error () ; 
  526.     ;
  527. #ifdef DEBUG
  528.     if ( interaction > 0 ) 
  529.     debughelp () ; 
  530. #endif /* DEBUG */
  531.     history = 3 ; 
  532.     jumpout () ; 
  533.   } 
  534. } 
  535. zoverflow ( s , n ) 
  536. strnumber s ; 
  537. integer n ; 
  538. {overflow_regmem 
  539.   normalizeselector () ; 
  540.   {
  541.     if ( interaction == 3 ) 
  542.     wakeupterminal () ; 
  543.     printnl ( 133 ) ; 
  544.     print ( 157 ) ; 
  545.   } 
  546.   print ( s ) ; 
  547.   printchar ( 61 ) ; 
  548.   printint ( n ) ; 
  549.   printchar ( 93 ) ; 
  550.   {
  551.     helpptr = 2 ; 
  552.     helpline [ 1 ] = 158 ; 
  553.     helpline [ 0 ] = 159 ; 
  554.   } 
  555.   {
  556.     if ( interaction == 3 ) 
  557.     interaction = 2 ; 
  558.     error () ; 
  559.     ;
  560. #ifdef DEBUG
  561.     if ( interaction > 0 ) 
  562.     debughelp () ; 
  563. #endif /* DEBUG */
  564.     history = 3 ; 
  565.     jumpout () ; 
  566.   } 
  567. } 
  568. zconfusion ( s ) 
  569. strnumber s ; 
  570. {confusion_regmem 
  571.   normalizeselector () ; 
  572.   if ( history < 2 ) 
  573.   {
  574.     {
  575.       if ( interaction == 3 ) 
  576.       wakeupterminal () ; 
  577.       printnl ( 133 ) ; 
  578.       print ( 160 ) ; 
  579.     } 
  580.     print ( s ) ; 
  581.     printchar ( 41 ) ; 
  582.     {
  583.       helpptr = 1 ; 
  584.       helpline [ 0 ] = 161 ; 
  585.     } 
  586.   } 
  587.   else {
  588.       
  589.     {
  590.       if ( interaction == 3 ) 
  591.       wakeupterminal () ; 
  592.       printnl ( 133 ) ; 
  593.       print ( 162 ) ; 
  594.     } 
  595.     {
  596.       helpptr = 2 ; 
  597.       helpline [ 1 ] = 163 ; 
  598.       helpline [ 0 ] = 164 ; 
  599.     } 
  600.   } 
  601.   {
  602.     if ( interaction == 3 ) 
  603.     interaction = 2 ; 
  604.     error () ; 
  605.     ;
  606. #ifdef DEBUG
  607.     if ( interaction > 0 ) 
  608.     debughelp () ; 
  609. #endif /* DEBUG */
  610.     history = 3 ; 
  611.     jumpout () ; 
  612.   } 
  613. } 
  614. boolean initterminal () {
  615.     /* 10 */ register boolean Result; 
  616.   initterminal_regmem 
  617.   topenin () ; 
  618.   if ( last > first ) 
  619.   {
  620.     curinput .locfield = first ; 
  621.     while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
  622.     == ' ' ) ) incr ( curinput .locfield ) ; 
  623.     if ( curinput .locfield < last ) 
  624.     {
  625.       Result = true ; 
  626.       return(Result) ; 
  627.     } 
  628.   } 
  629.   while ( true ) {
  630.       
  631.     wakeupterminal () ; 
  632. #ifdef RISC_OS
  633.     (void) Fput( stdout ,  "**" ) ; 
  634. #else
  635.     (void) Fputs( stdout ,  "**" ) ; 
  636. #endif
  637.     termflush ( stdout ) ; 
  638.     if ( ! inputln ( stdin , true ) ) 
  639.     {
  640.       (void) putc('\n',  stdout );
  641.       (void) Fputs( stdout ,  "! End of file on the terminal... why?" ) ; 
  642.       Result = false ; 
  643.       return(Result) ; 
  644.     } 
  645.     curinput .locfield = first ; 
  646.     while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
  647.     == 32 ) ) incr ( curinput .locfield ) ; 
  648.     if ( curinput .locfield < last ) 
  649.     {
  650.       Result = true ; 
  651.       return(Result) ; 
  652.     } 
  653. #ifdef RISC_OS
  654.     /* Don't know why they didn't do this in the first place... */
  655.     (void) Fputs( stdout , "Please type the name of your input file." ) ; 
  656.                /* Actually, stderr */
  657. #else
  658.     (void) fprintf( stdout , "%s\n",  "Please type the name of your input file." ) ; 
  659. #endif
  660.   } 
  661.   return(Result) ; 
  662. } 
  663. strnumber makestring () {
  664.     register strnumber Result; makestring_regmem 
  665.   if ( strptr == maxstrings ) 
  666.   overflow ( 129 , maxstrings - initstrptr ) ; 
  667.   incr ( strptr ) ; 
  668.   strstart [ strptr ] = poolptr ; 
  669.   Result = strptr - 1 ; 
  670.   return(Result) ; 
  671. } 
  672. boolean zstreqbuf ( s , k ) 
  673. strnumber s ; 
  674. integer k ; 
  675. {/* 45 */ register boolean Result; streqbuf_regmem 
  676.   poolpointer j  ; 
  677.   boolean result  ; 
  678.   j = strstart [ s ] ; 
  679.   while ( j < strstart [ s + 1 ] ) {
  680.       
  681.     if ( strpool [ j ] != buffer [ k ] ) 
  682.     {
  683.       result = false ; 
  684.       goto lab45 ; 
  685.     } 
  686.     incr ( j ) ; 
  687.     incr ( k ) ; 
  688.   } 
  689.   result = true ; 
  690.   lab45: Result = result ; 
  691.   return(Result) ; 
  692. } 
  693. boolean zstreqstr ( s , t ) 
  694. strnumber s , t ; 
  695. {/* 45 */ register boolean Result; streqstr_regmem 
  696.   poolpointer j, k  ; 
  697.   boolean result  ; 
  698.   result = false ; 
  699.   if ( ( strstart [ s + 1 ] - strstart [ s ] ) != ( strstart [ t + 1 ] - 
  700.   strstart [ t ] ) ) 
  701.   goto lab45 ; 
  702.   j = strstart [ s ] ; 
  703.   k = strstart [ t ] ; 
  704.   while ( j < strstart [ s + 1 ] ) {
  705.       
  706.     if ( strpool [ j ] != strpool [ k ] ) 
  707.     goto lab45 ; 
  708.     incr ( j ) ; 
  709.     incr ( k ) ; 
  710.   } 
  711.   result = true ; 
  712.   lab45: Result = result ; 
  713.   return(Result) ; 
  714. } 
  715. zprinttwo ( n ) 
  716. integer n ; 
  717. {printtwo_regmem 
  718.   n = abs ( n ) % 100 ; 
  719.   printchar ( 48 + ( n / 10 ) ) ; 
  720.   printchar ( 48 + ( n % 10 ) ) ; 
  721. } 
  722. zprinthex ( n ) 
  723. integer n ; 
  724. {printhex_regmem 
  725.   schar k  ; 
  726.   k = 0 ; 
  727.   printchar ( 34 ) ; 
  728.   do {
  729.       dig [ k ] = n % 16 ; 
  730.     n = n / 16 ; 
  731.     incr ( k ) ; 
  732.   } while ( ! ( n == 0 ) ) ; 
  733.   printthedigs ( k ) ; 
  734. } 
  735. zprintASCII ( c ) 
  736. integer c ; 
  737. {printASCII_regmem 
  738.   if ( ( c >= 0 ) && ( c <= 127 ) ) 
  739.   print ( c ) ; 
  740.   else {
  741.       
  742.     printchar ( 91 ) ; 
  743.     if ( c < 0 ) 
  744.     printint ( c ) ; 
  745.     else printhex ( c ) ; 
  746.     printchar ( 93 ) ; 
  747.   } 
  748. } 
  749. zprintromanint ( n ) 
  750. integer n ; 
  751. {/* 10 */ printromanint_regmem 
  752.   poolpointer j, k  ; 
  753.   nonnegativeinteger u, v  ; 
  754.   j = strstart [ 131 ] ; 
  755.   v = 1000 ; 
  756.   while ( true ) {
  757.       
  758.     while ( n >= v ) {
  759.     
  760.       printchar ( strpool [ j ] ) ; 
  761.       n = n - v ; 
  762.     } 
  763.     if ( n <= 0 ) 
  764.     return ; 
  765.     k = j + 2 ; 
  766.     u = v / ( strpool [ k - 1 ] - 48 ) ; 
  767.     if ( strpool [ k - 1 ] == 50 ) 
  768.     {
  769.       k = k + 2 ; 
  770.       u = u / ( strpool [ k - 1 ] - 48 ) ; 
  771.     } 
  772.     if ( n + u >= v ) 
  773.     {
  774.       printchar ( strpool [ k ] ) ; 
  775.       n = n + u ; 
  776.     } 
  777.     else {
  778.     
  779.       j = j + 2 ; 
  780.       v = v / ( strpool [ j - 1 ] - 48 ) ; 
  781.     } 
  782.   } 
  783. } 
  784. printcurrentstring () {
  785.     printcurrentstring_regmem 
  786.   poolpointer j  ; 
  787.   j = strstart [ strptr ] ; 
  788.   while ( j < poolptr ) {
  789.       
  790.     printchar ( strpool [ j ] ) ; 
  791.     incr ( j ) ; 
  792.   } 
  793. } 
  794. terminput () {
  795.     terminput_regmem 
  796.   integer k  ; 
  797.   termflush ( stdout ) ; 
  798.   if ( ! inputln ( stdin , true ) ) 
  799.   fatalerror ( 132 ) ; 
  800.   termoffset = 0 ; 
  801.   decr ( selector ) ; 
  802.   if ( last != first ) 
  803.   {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
  804.   for_end) do 
  805.     print ( buffer [ k ] ) ; 
  806.   while ( k++ < for_end ) ; } 
  807.   println () ; 
  808.   incr ( selector ) ; 
  809. } 
  810. zinterror ( n ) 
  811. integer n ; 
  812. {interror_regmem 
  813.   print ( 155 ) ; 
  814.   printint ( n ) ; 
  815.   printchar ( 41 ) ; 
  816.   error () ; 
  817. } 
  818. normalizeselector () {
  819.     normalizeselector_regmem 
  820.   if ( jobname > 0 ) 
  821.   selector = 19 ; 
  822.   else selector = 17 ; 
  823.   if ( jobname == 0 ) 
  824.   openlogfile () ; 
  825.   if ( interaction == 0 ) 
  826.   decr ( selector ) ; 
  827. } 
  828. pauseforinstructions () {
  829.     pauseforinstructions_regmem 
  830.   if ( OKtointerrupt ) 
  831.   {
  832.     interaction = 3 ; 
  833.     if ( ( selector == 18 ) || ( selector == 16 ) ) 
  834.     incr ( selector ) ; 
  835.     {
  836.       if ( interaction == 3 ) 
  837.       wakeupterminal () ; 
  838.       printnl ( 133 ) ; 
  839.       print ( 165 ) ; 
  840.     } 
  841.     {
  842.       helpptr = 3 ; 
  843.       helpline [ 2 ] = 166 ; 
  844.       helpline [ 1 ] = 167 ; 
  845.       helpline [ 0 ] = 168 ; 
  846.     } 
  847.     deletionsallowed = false ; 
  848.     error () ; 
  849.     deletionsallowed = true ; 
  850.     interrupt = 0 ; 
  851.   } 
  852. } 
  853. integer zhalf ( x ) 
  854. integer x ; 
  855. {register integer Result; half_regmem 
  856.   if ( odd ( x ) ) 
  857.   Result = ( x + 1 ) / 2 ; 
  858.   else Result = x / 2 ; 
  859.   return(Result) ; 
  860. } 
  861. scaled zrounddecimals ( k ) 
  862. smallnumber k ; 
  863. {register scaled Result; rounddecimals_regmem 
  864.   integer a  ; 
  865.   a = 0 ; 
  866.   while ( k > 0 ) {
  867.       
  868.     decr ( k ) ; 
  869.     a = ( a + dig [ k ] * 131072L ) / 10 ; 
  870.   } 
  871.   Result = ( a + 1 ) / 2 ; 
  872.   return(Result) ; 
  873. } 
  874. zprintscaled ( s ) 
  875. scaled s ; 
  876. {printscaled_regmem 
  877.   scaled delta  ; 
  878.   if ( s < 0 ) 
  879.   {
  880.     printchar ( 45 ) ; 
  881.     s = - (integer) s ; 
  882.   } 
  883.   printint ( s / 65536L ) ; 
  884.   printchar ( 46 ) ; 
  885.   s = 10 * ( s % 65536L ) + 5 ; 
  886.   delta = 10 ; 
  887.   do {
  888.       if ( delta > 65536L ) 
  889.     s = s + 32768L - ( delta / 2 ) ; 
  890.     printchar ( 48 + ( s / 65536L ) ) ; 
  891.     s = 10 * ( s % 65536L ) ; 
  892.     delta = delta * 10 ; 
  893.   } while ( ! ( s <= delta ) ) ; 
  894. } 
  895. scaled znxplusy ( n , x , y ) 
  896. integer n ; 
  897. scaled x , y ; 
  898. {register scaled Result; nxplusy_regmem 
  899.   if ( n < 0 ) 
  900.   {
  901.     x = - (integer) x ; 
  902.     n = - (integer) n ; 
  903.   } 
  904.   if ( n == 0 ) 
  905.   Result = y ; 
  906.   else if ( ( ( x <= ( 1073741823L - y ) / n ) && ( - (integer) x <= ( 
  907.   1073741823L + y ) / n ) ) ) 
  908.   Result = n * x + y ; 
  909.   else {
  910.       
  911.     aritherror = true ; 
  912.     Result = 0 ; 
  913.   } 
  914.   return(Result) ; 
  915. } 
  916. scaled zxovern ( x , n ) 
  917. scaled x ; 
  918. integer n ; 
  919. {register scaled Result; xovern_regmem 
  920.   boolean negative  ; 
  921.   negative = false ; 
  922.   if ( n == 0 ) 
  923.   {
  924.     aritherror = true ; 
  925.     Result = 0 ; 
  926.     remainder = x ; 
  927.   } 
  928.   else {
  929.       
  930.     if ( n < 0 ) 
  931.     {
  932.       x = - (integer) x ; 
  933.       n = - (integer) n ; 
  934.       negative = true ; 
  935.     } 
  936.     if ( x >= 0 ) 
  937.     {
  938.       Result = x / n ; 
  939.       remainder = x % n ; 
  940.     } 
  941.     else {
  942.     
  943.       Result = - (integer) ( ( - (integer) x ) / n ) ; 
  944.       remainder = - (integer) ( ( - (integer) x ) % n ) ; 
  945.     } 
  946.   } 
  947.   if ( negative ) 
  948.   remainder = - (integer) remainder ; 
  949.   return(Result) ; 
  950. } 
  951. scaled zxnoverd ( x , n , d ) 
  952. scaled x ; 
  953. integer n , d ; 
  954. {register scaled Result; xnoverd_regmem 
  955.   boolean positive  ; 
  956.   nonnegativeinteger t, u, v  ; 
  957.   if ( x >= 0 ) 
  958.   positive = true ; 
  959.   else {
  960.       
  961.     x = - (integer) x ; 
  962.     positive = false ; 
  963.   } 
  964.   t = ( x % 32768L ) * n ; 
  965.   u = ( x / 32768L ) * n + ( t / 32768L ) ; 
  966.   v = ( u % d ) * 32768L + ( t % 32768L ) ; 
  967.   if ( u / d >= 32768L ) 
  968.   aritherror = true ; 
  969.   else u = 32768L * ( u / d ) + ( v / d ) ; 
  970.   if ( positive ) 
  971.   {
  972.     Result = u ; 
  973.     remainder = v % d ; 
  974.   } 
  975.   else {
  976.       
  977.     Result = - (integer) u ; 
  978.     remainder = - (integer) ( v % d ) ; 
  979.   } 
  980.   return(Result) ; 
  981. } 
  982. halfword zbadness ( t , s ) 
  983. scaled t , s ; 
  984. {register halfword Result; badness_regmem 
  985.   integer r  ; 
  986.   if ( t == 0 ) 
  987.   Result = 0 ; 
  988.   else if ( s <= 0 ) 
  989.   Result = 10000 ; 
  990.   else {
  991.       
  992.     if ( t <= 7230584L ) 
  993.     r = ( t * 297 ) / s ; 
  994.     else if ( s >= 1663497L ) 
  995.     r = t / ( s / 297 ) ; 
  996.     else r = t ; 
  997.     if ( r > 1290 ) 
  998.     Result = 10000 ; 
  999.     else Result = ( r * r * r + 131072L ) / 262144L ; 
  1000.   } 
  1001.   return(Result) ; 
  1002. } 
  1003. #ifdef DEBUG
  1004. zprintword ( w ) 
  1005. memoryword w ; 
  1006. {printword_regmem 
  1007.   printint ( w .cint ) ; 
  1008.   printchar ( 32 ) ; 
  1009.   printscaled ( w .cint ) ; 
  1010.   printchar ( 32 ) ; 
  1011.   printscaled ( round ( 65536L * w .gr ) ) ; 
  1012.   println () ; 
  1013.   printint ( w .hh .v.LH ) ; 
  1014.   printchar ( 61 ) ; 
  1015.   printint ( w .hh.b0 ) ; 
  1016.   printchar ( 58 ) ; 
  1017.   printint ( w .hh.b1 ) ; 
  1018.   printchar ( 59 ) ; 
  1019.   printint ( w .hh .v.RH ) ; 
  1020.   printchar ( 32 ) ; 
  1021.   printint ( w .qqqq .b0 ) ; 
  1022.   printchar ( 58 ) ; 
  1023.   printint ( w .qqqq .b1 ) ; 
  1024.   printchar ( 58 ) ; 
  1025.   printint ( w .qqqq .b2 ) ; 
  1026.   printchar ( 58 ) ; 
  1027.   printint ( w .qqqq .b3 ) ; 
  1028. } 
  1029. #endif /* DEBUG */
  1030. zshowtokenlist ( p , q , l ) 
  1031. integer p , q ; 
  1032. integer l ; 
  1033. {/* 10 */ showtokenlist_regmem 
  1034.   integer m, c  ; 
  1035.   ASCIIcode matchchr  ; 
  1036.   ASCIIcode n  ; 
  1037.   matchchr = 35 ; 
  1038.   n = 48 ; 
  1039.   tally = 0 ; 
  1040.   while ( ( p != 0 ) && ( tally < l ) ) {
  1041.       
  1042.     if ( p == q ) 
  1043.     {
  1044.       firstcount = tally ; 
  1045.       trickcount = tally + 1 + errorline - halferrorline ; 
  1046.       if ( trickcount < errorline ) 
  1047.       trickcount = errorline ; 
  1048.     } 
  1049.     if ( ( p < himemmin ) || ( p > memend ) ) 
  1050.     {
  1051.       printesc ( 178 ) ; 
  1052.       return ; 
  1053.     } 
  1054.     if ( mem [ p ] .hh .v.LH >= 4096 ) 
  1055.     printcs ( mem [ p ] .hh .v.LH - 4096 ) ; 
  1056.     else {
  1057.     
  1058.       m = mem [ p ] .hh .v.LH / 256 ; 
  1059.       c = mem [ p ] .hh .v.LH % 256 ; 
  1060.       if ( ( c > 127 ) ) 
  1061.       printesc ( 413 ) ; 
  1062.       else switch ( m ) 
  1063.       {case 1 : 
  1064.       case 2 : 
  1065.       case 3 : 
  1066.       case 4 : 
  1067.       case 7 : 
  1068.       case 8 : 
  1069.       case 10 : 
  1070.       case 11 : 
  1071.       case 12 : 
  1072.     print ( c ) ; 
  1073.     break ; 
  1074.       case 6 : 
  1075.     {
  1076.       print ( c ) ; 
  1077.       print ( c ) ; 
  1078.     } 
  1079.     break ; 
  1080.       case 5 : 
  1081.     {
  1082.       print ( matchchr ) ; 
  1083.       if ( c <= 9 ) 
  1084.       printchar ( c + 48 ) ; 
  1085.       else {
  1086.           
  1087.         printchar ( 33 ) ; 
  1088.         return ; 
  1089.       } 
  1090.     } 
  1091.     break ; 
  1092.       case 13 : 
  1093.     {
  1094.       matchchr = c ; 
  1095.       print ( c ) ; 
  1096.       incr ( n ) ; 
  1097.       printchar ( n ) ; 
  1098.       if ( n > 57 ) 
  1099.       return ; 
  1100.     } 
  1101.     break ; 
  1102.       case 14 : 
  1103.     print ( 414 ) ; 
  1104.     break ; 
  1105.     default: 
  1106.     printesc ( 413 ) ; 
  1107.     break ; 
  1108.       } 
  1109.     } 
  1110.     p = mem [ p ] .hh .v.RH ; 
  1111.   } 
  1112.   if ( p != 0 ) 
  1113.   printesc ( 412 ) ; 
  1114. } 
  1115. runaway () {
  1116.     runaway_regmem 
  1117.   halfword p  ; 
  1118.   if ( scannerstatus > 1 ) 
  1119.   {
  1120.     printnl ( 427 ) ; 
  1121.     switch ( scannerstatus ) 
  1122.     {case 2 : 
  1123.       {
  1124.     print ( 428 ) ; 
  1125.     p = defref ; 
  1126.       } 
  1127.       break ; 
  1128.     case 3 : 
  1129.       {
  1130.     print ( 429 ) ; 
  1131.     p = memtop - 3 ; 
  1132.       } 
  1133.       break ; 
  1134.     case 4 : 
  1135.       {
  1136.     print ( 430 ) ; 
  1137.     p = memtop - 4 ; 
  1138.       } 
  1139.       break ; 
  1140.     case 5 : 
  1141.       {
  1142.     print ( 431 ) ; 
  1143.     p = defref ; 
  1144.       } 
  1145.       break ; 
  1146.     } 
  1147.     printchar ( 63 ) ; 
  1148.     println () ; 
  1149.     showtokenlist ( mem [ p ] .hh .v.RH , 0 , errorline - 10 ) ; 
  1150.   } 
  1151. } 
  1152. halfword getavail () {
  1153.     register halfword Result; getavail_regmem 
  1154.   halfword p  ; 
  1155.   p = avail ; 
  1156.   if ( p != 0 ) 
  1157.   avail = mem [ avail ] .hh .v.RH ; 
  1158.   else if ( memend < memmax ) 
  1159.   {
  1160.     incr ( memend ) ; 
  1161.     p = memend ; 
  1162.   } 
  1163.   else {
  1164.       
  1165.     decr ( himemmin ) ; 
  1166.     p = himemmin ; 
  1167.     if ( himemmin <= lomemmax ) 
  1168.     {
  1169.       runaway () ; 
  1170.       overflow ( 169 , memmax + 1 - memmin ) ; 
  1171.     } 
  1172.   } 
  1173.   mem [ p ] .hh .v.RH = 0 ; 
  1174.     ;
  1175. #ifdef STAT
  1176.   incr ( dynused ) ; 
  1177. #endif /* STAT */
  1178.   Result = p ; 
  1179.   return(Result) ; 
  1180. } 
  1181. zflushlist ( p ) 
  1182. halfword p ; 
  1183. {flushlist_regmem 
  1184.   halfword q, r  ; 
  1185.   if ( p != 0 ) 
  1186.   {
  1187.     r = p ; 
  1188.     do {
  1189.     q = r ; 
  1190.       r = mem [ r ] .hh .v.RH ; 
  1191.     ;
  1192. #ifdef STAT
  1193.       decr ( dynused ) ; 
  1194. #endif /* STAT */
  1195.     } while ( ! ( r == 0 ) ) ; 
  1196.     mem [ q ] .hh .v.RH = avail ; 
  1197.     avail = p ; 
  1198.   } 
  1199. } 
  1200. halfword zgetnode ( s ) 
  1201. integer s ; 
  1202. {/* 40 10 20 */ register halfword Result; getnode_regmem 
  1203.   halfword p  ; 
  1204.   halfword q  ; 
  1205.   integer r  ; 
  1206.   integer t  ; 
  1207.   lab20: p = rover ; 
  1208.   do {
  1209.       q = p + mem [ p ] .hh .v.LH ; 
  1210.     while ( ( mem [ q ] .hh .v.RH == 65535L ) ) {
  1211.     
  1212.       t = mem [ q + 1 ] .hh .v.RH ; 
  1213.       if ( q == rover ) 
  1214.       rover = t ; 
  1215.       mem [ t + 1 ] .hh .v.LH = mem [ q + 1 ] .hh .v.LH ; 
  1216.       mem [ mem [ q + 1 ] .hh .v.LH + 1 ] .hh .v.RH = t ; 
  1217.       q = q + mem [ q ] .hh .v.LH ; 
  1218.     } 
  1219.     r = q - s ; 
  1220.     if ( r > toint ( p + 1 ) ) 
  1221.     {
  1222.       mem [ p ] .hh .v.LH = r - p ; 
  1223.       rover = p ; 
  1224.       goto lab40 ; 
  1225.     } 
  1226.     if ( r == p ) 
  1227.     if ( mem [ p + 1 ] .hh .v.RH != p ) 
  1228.     {
  1229.       rover = mem [ p + 1 ] .hh .v.RH ; 
  1230.       t = mem [ p + 1 ] .hh .v.LH ; 
  1231.       mem [ rover + 1 ] .hh .v.LH = t ; 
  1232.       mem [ t + 1 ] .hh .v.RH = rover ; 
  1233.       goto lab40 ; 
  1234.     } 
  1235.     mem [ p ] .hh .v.LH = q - p ; 
  1236.     p = mem [ p + 1 ] .hh .v.RH ; 
  1237.   } while ( ! ( p == rover ) ) ; 
  1238.   if ( s == 1073741824L ) 
  1239.   {
  1240.     Result = 65535L ; 
  1241.     return(Result) ; 
  1242.   } 
  1243.   if ( lomemmax + 2 < himemmin ) 
  1244.   if ( lomemmax + 2 <= 65535L ) 
  1245.   {
  1246.     if ( lomemmax + 1000 < himemmin ) 
  1247.     t = lomemmax + 1000 ; 
  1248.     else t = ( lomemmax + himemmin + 2 ) / 2 ; 
  1249.     p = mem [ rover + 1 ] .hh .v.LH ; 
  1250.     q = lomemmax ; 
  1251.     mem [ p + 1 ] .hh .v.RH = q ; 
  1252.     mem [ rover + 1 ] .hh .v.LH = q ; 
  1253.     if ( t > 65535L ) 
  1254.     t = 65535L ; 
  1255.     mem [ q + 1 ] .hh .v.RH = rover ; 
  1256.     mem [ q + 1 ] .hh .v.LH = p ; 
  1257.     mem [ q ] .hh .v.RH = 65535L ; 
  1258.     mem [ q ] .hh .v.LH = t - lomemmax ; 
  1259.     lomemmax = t ; 
  1260.     mem [ lomemmax ] .hh .v.RH = 0 ; 
  1261.     mem [ lomemmax ] .hh .v.LH = 0 ; 
  1262.     rover = q ; 
  1263.     goto lab20 ; 
  1264.   } 
  1265.   overflow ( 169 , memmax + 1 - memmin ) ; 
  1266.   lab40: mem [ r ] .hh .v.RH = 0 ; 
  1267.     ;
  1268. #ifdef STAT
  1269.   varused = varused + s ; 
  1270. #endif /* STAT */
  1271.   Result = r ; 
  1272.   return(Result) ; 
  1273. } 
  1274. zfreenode ( p , s ) 
  1275. halfword p ; 
  1276. halfword s ; 
  1277. {freenode_regmem 
  1278.   halfword q  ; 
  1279.   mem [ p ] .hh .v.LH = s ; 
  1280.   mem [ p ] .hh .v.RH = 65535L ; 
  1281.   q = mem [ rover + 1 ] .hh .v.LH ; 
  1282.   mem [ p + 1 ] .hh .v.LH = q ; 
  1283.   mem [ p + 1 ] .hh .v.RH = rover ; 
  1284.   mem [ rover + 1 ] .hh .v.LH = p ; 
  1285.   mem [ q + 1 ] .hh .v.RH = p ; 
  1286.     ;
  1287. #ifdef STAT
  1288.   varused = varused - s ; 
  1289. #endif /* STAT */
  1290. } 
  1291. halfword newnullbox () {
  1292.     register halfword Result; newnullbox_regmem 
  1293.   halfword p  ; 
  1294.   p = getnode ( 7 ) ; 
  1295.   mem [ p ] .hh.b0 = 0 ; 
  1296.   mem [ p ] .hh.b1 = 0 ; 
  1297.   mem [ p + 1 ] .cint = 0 ; 
  1298.   mem [ p + 2 ] .cint = 0 ; 
  1299.   mem [ p + 3 ] .cint = 0 ; 
  1300.   mem [ p + 4 ] .cint = 0 ; 
  1301.   mem [ p + 5 ] .hh .v.RH = 0 ; 
  1302.   mem [ p + 5 ] .hh.b0 = 0 ; 
  1303.   mem [ p + 5 ] .hh.b1 = 0 ; 
  1304.   mem [ p + 6 ] .gr = 0.0 ; 
  1305.   Result = p ; 
  1306.   return(Result) ; 
  1307. } 
  1308. halfword newrule () {
  1309.     register halfword Result; newrule_regmem 
  1310.   halfword p  ; 
  1311.   p = getnode ( 4 ) ; 
  1312.   mem [ p ] .hh.b0 = 2 ; 
  1313.   mem [ p ] .hh.b1 = 0 ; 
  1314.   mem [ p + 1 ] .cint = -1073741824L ; 
  1315.   mem [ p + 2 ] .cint = -1073741824L ; 
  1316.   mem [ p + 3 ] .cint = -1073741824L ; 
  1317.   Result = p ; 
  1318.   return(Result) ; 
  1319. } 
  1320. halfword znewligature ( f , c , q ) 
  1321. quarterword f , c ; 
  1322. halfword q ; 
  1323. {register halfword Result; newligature_regmem 
  1324.   halfword p  ; 
  1325.   p = getnode ( 2 ) ; 
  1326.   mem [ p ] .hh.b0 = 6 ; 
  1327.   mem [ p ] .hh.b1 = 0 ; 
  1328.   mem [ p + 1 ] .hh.b0 = f ; 
  1329.   mem [ p + 1 ] .hh.b1 = c ; 
  1330.   mem [ p + 1 ] .hh .v.RH = q ; 
  1331.   Result = p ; 
  1332.   return(Result) ; 
  1333. } 
  1334. halfword newdisc () {
  1335.     register halfword Result; newdisc_regmem 
  1336.   halfword p  ; 
  1337.   p = getnode ( 2 ) ; 
  1338.   mem [ p ] .hh.b0 = 7 ; 
  1339.   mem [ p ] .hh.b1 = 0 ; 
  1340.   mem [ p + 1 ] .hh .v.LH = 0 ; 
  1341.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  1342.   Result = p ; 
  1343.   return(Result) ; 
  1344. } 
  1345. halfword znewmath ( w , s ) 
  1346. scaled w ; 
  1347. smallnumber s ; 
  1348. {register halfword Result; newmath_regmem 
  1349.   halfword p  ; 
  1350.   p = getnode ( 2 ) ; 
  1351.   mem [ p ] .hh.b0 = 9 ; 
  1352.   mem [ p ] .hh.b1 = s ; 
  1353.   mem [ p + 1 ] .cint = w ; 
  1354.   Result = p ; 
  1355.   return(Result) ; 
  1356. } 
  1357. halfword znewspec ( p ) 
  1358. halfword p ; 
  1359. {register halfword Result; newspec_regmem 
  1360.   halfword q  ; 
  1361.   q = getnode ( 4 ) ; 
  1362.   mem [ q ] = mem [ p ] ; 
  1363.   mem [ q ] .hh .v.RH = 0 ; 
  1364.   mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  1365.   mem [ q + 2 ] .cint = mem [ p + 2 ] .cint ; 
  1366.   mem [ q + 3 ] .cint = mem [ p + 3 ] .cint ; 
  1367.   Result = q ; 
  1368.   return(Result) ; 
  1369. } 
  1370. halfword znewparamglue ( n ) 
  1371. smallnumber n ; 
  1372. {register halfword Result; newparamglue_regmem 
  1373.   halfword p  ; 
  1374.   halfword q  ; 
  1375.   p = getnode ( 2 ) ; 
  1376.   mem [ p ] .hh.b0 = 10 ; 
  1377.   mem [ p ] .hh.b1 = n + 1 ; 
  1378.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  1379.   q = eqtb [ 3526 + n ] .hh .v.RH ; 
  1380.   mem [ p + 1 ] .hh .v.LH = q ; 
  1381.   incr ( mem [ q ] .hh .v.RH ) ; 
  1382.   Result = p ; 
  1383.   return(Result) ; 
  1384. } 
  1385. halfword znewglue ( q ) 
  1386. halfword q ; 
  1387. {register halfword Result; newglue_regmem 
  1388.   halfword p  ; 
  1389.   p = getnode ( 2 ) ; 
  1390.   mem [ p ] .hh.b0 = 10 ; 
  1391.   mem [ p ] .hh.b1 = 0 ; 
  1392.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  1393.   mem [ p + 1 ] .hh .v.LH = q ; 
  1394.   incr ( mem [ q ] .hh .v.RH ) ; 
  1395.   Result = p ; 
  1396.   return(Result) ; 
  1397. } 
  1398. halfword znewskipparam ( n ) 
  1399. smallnumber n ; 
  1400. {register halfword Result; newskipparam_regmem 
  1401.   halfword p  ; 
  1402.   tempptr = newspec ( eqtb [ 3526 + n ] .hh .v.RH ) ; 
  1403.   p = newglue ( tempptr ) ; 
  1404.   mem [ tempptr ] .hh .v.RH = 0 ; 
  1405.   mem [ p ] .hh.b1 = n + 1 ; 
  1406.   Result = p ; 
  1407.   return(Result) ; 
  1408. } 
  1409. halfword znewkern ( w ) 
  1410. scaled w ; 
  1411. {register halfword Result; newkern_regmem 
  1412.   halfword p  ; 
  1413.   p = getnode ( 2 ) ; 
  1414.   mem [ p ] .hh.b0 = 11 ; 
  1415.   mem [ p ] .hh.b1 = 0 ; 
  1416.   mem [ p + 1 ] .cint = w ; 
  1417.   Result = p ; 
  1418.   return(Result) ; 
  1419. } 
  1420. halfword znewpenalty ( m ) 
  1421. integer m ; 
  1422. {register halfword Result; newpenalty_regmem 
  1423.   halfword p  ; 
  1424.   p = getnode ( 2 ) ; 
  1425.   mem [ p ] .hh.b0 = 12 ; 
  1426.   mem [ p ] .hh.b1 = 0 ; 
  1427.   mem [ p + 1 ] .cint = m ; 
  1428.   Result = p ; 
  1429.   return(Result) ; 
  1430. } 
  1431. #ifdef DEBUG
  1432. zcheckmem ( printlocs ) 
  1433. boolean printlocs ; 
  1434. {/* 31 32 */ checkmem_regmem 
  1435.   halfword p, q  ; 
  1436.   boolean clobbered  ; 
  1437.   {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <= 
  1438.   for_end) do 
  1439.     freearr [ p ] = false ; 
  1440.   while ( p++ < for_end ) ; } 
  1441.   {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  1442.   for_end) do 
  1443.     freearr [ p ] = false ; 
  1444.   while ( p++ < for_end ) ; } 
  1445.   p = avail ; 
  1446.   q = 0 ; 
  1447.   clobbered = false ; 
  1448.   while ( p != 0 ) {
  1449.       
  1450.     if ( ( p > memend ) || ( p < himemmin ) ) 
  1451.     clobbered = true ; 
  1452.     else if ( freearr [ p ] ) 
  1453.     clobbered = true ; 
  1454.     if ( clobbered ) 
  1455.     {
  1456.       printnl ( 170 ) ; 
  1457.       printint ( q ) ; 
  1458.       goto lab31 ; 
  1459.     } 
  1460.     freearr [ p ] = true ; 
  1461.     q = p ; 
  1462.     p = mem [ q ] .hh .v.RH ; 
  1463.   } 
  1464.   lab31: ; 
  1465.   p = rover ; 
  1466.   q = 0 ; 
  1467.   clobbered = false ; 
  1468.   do {
  1469.       if ( ( p >= lomemmax ) || ( p < memmin ) ) 
  1470.     clobbered = true ; 
  1471.     else if ( ( mem [ p + 1 ] .hh .v.RH >= lomemmax ) || ( mem [ p + 1 ] .hh 
  1472.     .v.RH < memmin ) ) 
  1473.     clobbered = true ; 
  1474.     else if ( ! ( ( mem [ p ] .hh .v.RH == 65535L ) ) || ( mem [ p ] .hh .v.LH 
  1475.     < 2 ) || ( p + mem [ p ] .hh .v.LH > lomemmax ) || ( mem [ mem [ p + 1 ] 
  1476.     .hh .v.RH + 1 ] .hh .v.LH != p ) ) 
  1477.     clobbered = true ; 
  1478.     if ( clobbered ) 
  1479.     {
  1480.       printnl ( 171 ) ; 
  1481.       printint ( q ) ; 
  1482.       goto lab32 ; 
  1483.     } 
  1484.     {register integer for_end; q = p ; for_end = p + mem [ p ] .hh .v.LH - 1 
  1485.     ; if ( q <= for_end) do 
  1486.       {
  1487.     if ( freearr [ q ] ) 
  1488.     {
  1489.       printnl ( 172 ) ; 
  1490.       printint ( q ) ; 
  1491.       goto lab32 ; 
  1492.     } 
  1493.     freearr [ q ] = true ; 
  1494.       } 
  1495.     while ( q++ < for_end ) ; } 
  1496.     q = p ; 
  1497.     p = mem [ p + 1 ] .hh .v.RH ; 
  1498.   } while ( ! ( p == rover ) ) ; 
  1499.   lab32: ; 
  1500.   p = memmin ; 
  1501.   while ( p <= lomemmax ) {
  1502.       
  1503.     if ( ( mem [ p ] .hh .v.RH == 65535L ) ) 
  1504.     {
  1505.       printnl ( 173 ) ; 
  1506.       printint ( p ) ; 
  1507.     } 
  1508.     while ( ( p <= lomemmax ) && ! freearr [ p ] ) incr ( p ) ; 
  1509.     while ( ( p <= lomemmax ) && freearr [ p ] ) incr ( p ) ; 
  1510.   } 
  1511.   if ( printlocs ) 
  1512.   {
  1513.     printnl ( 174 ) ; 
  1514.     {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <= 
  1515.     for_end) do 
  1516.       if ( ! freearr [ p ] && ( ( p > waslomax ) || wasfree [ p ] ) ) 
  1517.       {
  1518.     printchar ( 32 ) ; 
  1519.     printint ( p ) ; 
  1520.       } 
  1521.     while ( p++ < for_end ) ; } 
  1522.     {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  1523.     for_end) do 
  1524.       if ( ! freearr [ p ] && ( ( p < washimin ) || ( p > wasmemend ) || 
  1525.       wasfree [ p ] ) ) 
  1526.       {
  1527.     printchar ( 32 ) ; 
  1528.     printint ( p ) ; 
  1529.       } 
  1530.     while ( p++ < for_end ) ; } 
  1531.   } 
  1532.   {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <= 
  1533.   for_end) do 
  1534.     wasfree [ p ] = freearr [ p ] ; 
  1535.   while ( p++ < for_end ) ; } 
  1536.   {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  1537.   for_end) do 
  1538.     wasfree [ p ] = freearr [ p ] ; 
  1539.   while ( p++ < for_end ) ; } 
  1540.   wasmemend = memend ; 
  1541.   waslomax = lomemmax ; 
  1542.   washimin = himemmin ; 
  1543. } 
  1544. #endif /* DEBUG */
  1545. #ifdef DEBUG
  1546. zsearchmem ( p ) 
  1547. halfword p ; 
  1548. {searchmem_regmem 
  1549.   integer q  ; 
  1550.   {register integer for_end; q = memmin ; for_end = lomemmax ; if ( q <= 
  1551.   for_end) do 
  1552.     {
  1553.       if ( mem [ q ] .hh .v.RH == p ) 
  1554.       {
  1555.     printnl ( 175 ) ; 
  1556.     printint ( q ) ; 
  1557.     printchar ( 41 ) ; 
  1558.       } 
  1559.       if ( mem [ q ] .hh .v.LH == p ) 
  1560.       {
  1561.     printnl ( 176 ) ; 
  1562.     printint ( q ) ; 
  1563.     printchar ( 41 ) ; 
  1564.       } 
  1565.     } 
  1566.   while ( q++ < for_end ) ; } 
  1567.   {register integer for_end; q = himemmin ; for_end = memend ; if ( q <= 
  1568.   for_end) do 
  1569.     {
  1570.       if ( mem [ q ] .hh .v.RH == p ) 
  1571.       {
  1572.     printnl ( 175 ) ; 
  1573.     printint ( q ) ; 
  1574.     printchar ( 41 ) ; 
  1575.       } 
  1576.       if ( mem [ q ] .hh .v.LH == p ) 
  1577.       {
  1578.     printnl ( 176 ) ; 
  1579.     printint ( q ) ; 
  1580.     printchar ( 41 ) ; 
  1581.       } 
  1582.     } 
  1583.   while ( q++ < for_end ) ; } 
  1584.   {register integer for_end; q = 1 ; for_end = 4577 ; if ( q <= for_end) do 
  1585.     {
  1586.       if ( eqtb [ q ] .hh .v.RH == p ) 
  1587.       {
  1588.     printnl ( 360 ) ; 
  1589.     printint ( q ) ; 
  1590.     printchar ( 41 ) ; 
  1591.       } 
  1592.     } 
  1593.   while ( q++ < for_end ) ; } 
  1594.   if ( saveptr > 0 ) 
  1595.   {register integer for_end; q = 0 ; for_end = saveptr - 1 ; if ( q <= 
  1596.   for_end) do 
  1597.     {
  1598.       if ( savestack [ q ] .hh .v.RH == p ) 
  1599.       {
  1600.     printnl ( 404 ) ; 
  1601.     printint ( q ) ; 
  1602.     printchar ( 41 ) ; 
  1603.       } 
  1604.     } 
  1605.   while ( q++ < for_end ) ; } 
  1606.   {register integer for_end; q = 0 ; for_end = 307 ; if ( q <= for_end) do 
  1607.     {
  1608.       if ( hyphlist [ q ] == p ) 
  1609.       {
  1610.     printnl ( 792 ) ; 
  1611.     printint ( q ) ; 
  1612.     printchar ( 41 ) ; 
  1613.       } 
  1614.     } 
  1615.   while ( q++ < for_end ) ; } 
  1616. } 
  1617. #endif /* DEBUG */
  1618. zshortdisplay ( p ) 
  1619. integer p ; 
  1620. {shortdisplay_regmem 
  1621.   integer n  ; 
  1622.   while ( p > memmin ) {
  1623.       
  1624.     if ( ( p >= himemmin ) ) 
  1625.     {
  1626.       if ( p <= memend ) 
  1627.       {
  1628.     if ( mem [ p ] .hh.b0 != fontinshortdisplay ) 
  1629.     {
  1630.       if ( ( mem [ p ] .hh.b0 > fontmax ) ) 
  1631.       printchar ( 42 ) ; 
  1632.       else printesc ( hash [ 3268 + mem [ p ] .hh.b0 ] .v.RH ) ; 
  1633.       printchar ( 32 ) ; 
  1634.       fontinshortdisplay = mem [ p ] .hh.b0 ; 
  1635.     } 
  1636.     printASCII ( mem [ p ] .hh.b1 ) ; 
  1637.       } 
  1638.     } 
  1639.     else switch ( mem [ p ] .hh.b0 ) 
  1640.     {case 0 : 
  1641.     case 1 : 
  1642.     case 3 : 
  1643.     case 8 : 
  1644.     case 4 : 
  1645.     case 5 : 
  1646.     case 13 : 
  1647.       print ( 177 ) ; 
  1648.       break ; 
  1649.     case 2 : 
  1650.       printchar ( 124 ) ; 
  1651.       break ; 
  1652.     case 10 : 
  1653.       if ( mem [ p + 1 ] .hh .v.LH != 0 ) 
  1654.       printchar ( 32 ) ; 
  1655.       break ; 
  1656.     case 9 : 
  1657.       printchar ( 36 ) ; 
  1658.       break ; 
  1659.     case 6 : 
  1660.       shortdisplay ( mem [ p + 1 ] .hh .v.RH ) ; 
  1661.       break ; 
  1662.     case 7 : 
  1663.       {
  1664.     shortdisplay ( mem [ p + 1 ] .hh .v.LH ) ; 
  1665.     shortdisplay ( mem [ p + 1 ] .hh .v.RH ) ; 
  1666.     n = mem [ p ] .hh.b1 ; 
  1667.     while ( n > 0 ) {
  1668.         
  1669.       if ( mem [ p ] .hh .v.RH != 0 ) 
  1670.       p = mem [ p ] .hh .v.RH ; 
  1671.       decr ( n ) ; 
  1672.     } 
  1673.       } 
  1674.       break ; 
  1675.       default: 
  1676.       ; 
  1677.       break ; 
  1678.     } 
  1679.     p = mem [ p ] .hh .v.RH ; 
  1680.   } 
  1681. } 
  1682. zprintfontandchar ( p ) 
  1683. integer p ; 
  1684. {printfontandchar_regmem 
  1685.   if ( p > memend ) 
  1686.   printesc ( 178 ) ; 
  1687.   else {
  1688.       
  1689.     if ( ( mem [ p ] .hh.b0 > fontmax ) ) 
  1690.     printchar ( 42 ) ; 
  1691.     else printesc ( hash [ 3268 + mem [ p ] .hh.b0 ] .v.RH ) ; 
  1692.     printchar ( 32 ) ; 
  1693.     printASCII ( mem [ p ] .hh.b1 ) ; 
  1694.   } 
  1695. } 
  1696. zprintmark ( p ) 
  1697. integer p ; 
  1698. {printmark_regmem 
  1699.   printchar ( 123 ) ; 
  1700.   if ( ( p < himemmin ) || ( p > memend ) ) 
  1701.   printesc ( 178 ) ; 
  1702.   else showtokenlist ( mem [ p ] .hh .v.RH , 0 , maxprintline - 10 ) ; 
  1703.   printchar ( 125 ) ; 
  1704. } 
  1705. zprintruledimen ( d ) 
  1706. scaled d ; 
  1707. {printruledimen_regmem 
  1708.   if ( ( d == -1073741824L ) ) 
  1709.   printchar ( 42 ) ; 
  1710.   else printscaled ( d ) ; 
  1711. } 
  1712. zprintglue ( d , order , s ) 
  1713. scaled d ; 
  1714. integer order ; 
  1715. strnumber s ; 
  1716. {printglue_regmem 
  1717.   printscaled ( d ) ; 
  1718.   if ( ( order < 0 ) || ( order > 3 ) ) 
  1719.   print ( 179 ) ; 
  1720.   else if ( order > 0 ) 
  1721.   {
  1722.     print ( 180 ) ; 
  1723.     while ( order > 1 ) {
  1724.     
  1725.       printchar ( 108 ) ; 
  1726.       decr ( order ) ; 
  1727.     } 
  1728.   } 
  1729.   else if ( s != 0 ) 
  1730.   print ( s ) ; 
  1731. } 
  1732. zprintspec ( p , s ) 
  1733. integer p ; 
  1734. strnumber s ; 
  1735. {printspec_regmem 
  1736.   if ( ( p < memmin ) || ( p >= lomemmax ) ) 
  1737.   printchar ( 42 ) ; 
  1738.   else {
  1739.       
  1740.     printscaled ( mem [ p + 1 ] .cint ) ; 
  1741.     if ( s != 0 ) 
  1742.     print ( s ) ; 
  1743.     if ( mem [ p + 2 ] .cint != 0 ) 
  1744.     {
  1745.       print ( 181 ) ; 
  1746.       printglue ( mem [ p + 2 ] .cint , mem [ p ] .hh.b0 , s ) ; 
  1747.     } 
  1748.     if ( mem [ p + 3 ] .cint != 0 ) 
  1749.     {
  1750.       print ( 182 ) ; 
  1751.       printglue ( mem [ p + 3 ] .cint , mem [ p ] .hh.b1 , s ) ; 
  1752.     } 
  1753.   } 
  1754. } 
  1755. zprintfamandchar ( p ) 
  1756. halfword p ; 
  1757. {printfamandchar_regmem 
  1758.   printesc ( 329 ) ; 
  1759.   printint ( mem [ p ] .hh.b0 ) ; 
  1760.   printchar ( 32 ) ; 
  1761.   printASCII ( mem [ p ] .hh.b1 ) ; 
  1762. } 
  1763. zprintdelimiter ( p ) 
  1764. halfword p ; 
  1765. {printdelimiter_regmem 
  1766.   integer a  ; 
  1767.   a = mem [ p ] .qqqq .b0 * 256 + mem [ p ] .qqqq .b1 ; 
  1768.   a = a * 4096 + mem [ p ] .qqqq .b2 * 256 + mem [ p ] .qqqq .b3 ; 
  1769.   if ( a < 0 ) 
  1770.   printint ( a ) ; 
  1771.   else printhex ( a ) ; 
  1772. } 
  1773. zprintsubsidiarydata ( p , c ) 
  1774. halfword p ; 
  1775. ASCIIcode c ; 
  1776. {printsubsidiarydata_regmem 
  1777.   if ( ( poolptr - strstart [ strptr ] ) >= depththreshold ) 
  1778.   {
  1779.     if ( mem [ p ] .hh .v.RH != 0 ) 
  1780.     print ( 183 ) ; 
  1781.   } 
  1782.   else {
  1783.       
  1784.     {
  1785.       strpool [ poolptr ] = c ; 
  1786.       incr ( poolptr ) ; 
  1787.     } 
  1788.     tempptr = p ; 
  1789.     switch ( mem [ p ] .hh .v.RH ) 
  1790.     {case 1 : 
  1791.       {
  1792.     println () ; 
  1793.     printcurrentstring () ; 
  1794.     printfamandchar ( p ) ; 
  1795.       } 
  1796.       break ; 
  1797.     case 2 : 
  1798.       showinfo () ; 
  1799.       break ; 
  1800.     case 3 : 
  1801.       if ( mem [ p ] .hh .v.LH == 0 ) 
  1802.       {
  1803.     println () ; 
  1804.     printcurrentstring () ; 
  1805.     print ( 713 ) ; 
  1806.       } 
  1807.       else showinfo () ; 
  1808.       break ; 
  1809.       default: 
  1810.       ; 
  1811.       break ; 
  1812.     } 
  1813.     decr ( poolptr ) ; 
  1814.   } 
  1815. } 
  1816. zprintstyle ( c ) 
  1817. integer c ; 
  1818. {printstyle_regmem 
  1819.   switch ( c / 2 ) 
  1820.   {case 0 : 
  1821.     printesc ( 714 ) ; 
  1822.     break ; 
  1823.   case 1 : 
  1824.     printesc ( 715 ) ; 
  1825.     break ; 
  1826.   case 2 : 
  1827.     printesc ( 716 ) ; 
  1828.     break ; 
  1829.   case 3 : 
  1830.     printesc ( 717 ) ; 
  1831.     break ; 
  1832.     default: 
  1833.     print ( 718 ) ; 
  1834.     break ; 
  1835.   } 
  1836. } 
  1837. zprintskipparam ( n ) 
  1838. integer n ; 
  1839. {printskipparam_regmem 
  1840.   switch ( n ) 
  1841.   {case 0 : 
  1842.     printesc ( 241 ) ; 
  1843.     break ; 
  1844.   case 1 : 
  1845.     printesc ( 242 ) ; 
  1846.     break ; 
  1847.   case 2 : 
  1848.     printesc ( 243 ) ; 
  1849.     break ; 
  1850.   case 3 : 
  1851.     printesc ( 244 ) ; 
  1852.     break ; 
  1853.   case 4 : 
  1854.     printesc ( 245 ) ; 
  1855.     break ; 
  1856.   case 5 : 
  1857.     printesc ( 246 ) ; 
  1858.     break ; 
  1859.   case 6 : 
  1860.     printesc ( 247 ) ; 
  1861.     break ; 
  1862.   case 7 : 
  1863.     printesc ( 248 ) ; 
  1864.     break ; 
  1865.   case 8 : 
  1866.     printesc ( 249 ) ; 
  1867.     break ; 
  1868.   case 9 : 
  1869.     printesc ( 250 ) ; 
  1870.     break ; 
  1871.   case 10 : 
  1872.     printesc ( 251 ) ; 
  1873.     break ; 
  1874.   case 11 : 
  1875.     printesc ( 252 ) ; 
  1876.     break ; 
  1877.   case 12 : 
  1878.     printesc ( 253 ) ; 
  1879.     break ; 
  1880.   case 13 : 
  1881.     printesc ( 254 ) ; 
  1882.     break ; 
  1883.   case 14 : 
  1884.     printesc ( 255 ) ; 
  1885.     break ; 
  1886.   case 15 : 
  1887.     printesc ( 256 ) ; 
  1888.     break ; 
  1889.   case 16 : 
  1890.     printesc ( 257 ) ; 
  1891.     break ; 
  1892.   case 17 : 
  1893.     printesc ( 258 ) ; 
  1894.     break ; 
  1895.     default: 
  1896.     print ( 259 ) ; 
  1897.     break ; 
  1898.   } 
  1899. } 
  1900. zshownodelist ( p ) 
  1901. integer p ; 
  1902. {/* 10 */ shownodelist_regmem 
  1903.   integer n  ; 
  1904.   real g  ; 
  1905.   if ( ( poolptr - strstart [ strptr ] ) > depththreshold ) 
  1906.   {
  1907.     if ( p > 0 ) 
  1908.     print ( 183 ) ; 
  1909.     return ; 
  1910.   } 
  1911.   n = 0 ; 
  1912.   while ( p > memmin ) {
  1913.       
  1914.     println () ; 
  1915.     printcurrentstring () ; 
  1916.     if ( p > memend ) 
  1917.     {
  1918.       print ( 184 ) ; 
  1919.       return ; 
  1920.     } 
  1921.     incr ( n ) ; 
  1922.     if ( n > breadthmax ) 
  1923.     {
  1924.       print ( 185 ) ; 
  1925.       return ; 
  1926.     } 
  1927.     if ( ( p >= himemmin ) ) 
  1928.     printfontandchar ( p ) ; 
  1929.     else switch ( mem [ p ] .hh.b0 ) 
  1930.     {case 0 : 
  1931.     case 1 : 
  1932.     case 13 : 
  1933.       {
  1934.     if ( mem [ p ] .hh.b0 == 0 ) 
  1935.     printesc ( 104 ) ; 
  1936.     else if ( mem [ p ] .hh.b0 == 1 ) 
  1937.     printesc ( 118 ) ; 
  1938.     else printesc ( 187 ) ; 
  1939.     print ( 188 ) ; 
  1940.     printscaled ( mem [ p + 3 ] .cint ) ; 
  1941.     printchar ( 43 ) ; 
  1942.     printscaled ( mem [ p + 2 ] .cint ) ; 
  1943.     print ( 189 ) ; 
  1944.     printscaled ( mem [ p + 1 ] .cint ) ; 
  1945.     if ( mem [ p ] .hh.b0 == 13 ) 
  1946.     {
  1947.       if ( mem [ p ] .hh.b1 != 0 ) 
  1948.       {
  1949.         print ( 155 ) ; 
  1950.         printint ( mem [ p ] .hh.b1 + 1 ) ; 
  1951.         print ( 191 ) ; 
  1952.       } 
  1953.       if ( mem [ p + 6 ] .cint != 0 ) 
  1954.       {
  1955.         print ( 192 ) ; 
  1956.         printglue ( mem [ p + 6 ] .cint , mem [ p + 5 ] .hh.b1 , 0 ) ; 
  1957.       } 
  1958.       if ( mem [ p + 4 ] .cint != 0 ) 
  1959.       {
  1960.         print ( 193 ) ; 
  1961.         printglue ( mem [ p + 4 ] .cint , mem [ p + 5 ] .hh.b0 , 0 ) ; 
  1962.       } 
  1963.     } 
  1964.     else {
  1965.         
  1966.       g = mem [ p + 6 ] .gr ; 
  1967.       if ( ( g != 0.0 ) && ( mem [ p + 5 ] .hh.b0 != 0 ) ) 
  1968.       {
  1969.         print ( 194 ) ; 
  1970.         if ( mem [ p + 5 ] .hh.b0 == 2 ) 
  1971.         print ( 195 ) ; 
  1972.         if ( fabs ( g ) > 20000.0 ) 
  1973.         {
  1974.           if ( g > 0.0 ) 
  1975.           printchar ( 62 ) ; 
  1976.           else print ( 196 ) ; 
  1977.           printglue ( 20000 * 65536L , mem [ p + 5 ] .hh.b1 , 0 ) ; 
  1978.         } 
  1979.         else printglue ( round ( 65536L * g ) , mem [ p + 5 ] .hh.b1 , 0 ) 
  1980.         ; 
  1981.       } 
  1982.       if ( mem [ p + 4 ] .cint != 0 ) 
  1983.       {
  1984.         print ( 190 ) ; 
  1985.         printscaled ( mem [ p + 4 ] .cint ) ; 
  1986.       } 
  1987.     } 
  1988.     {
  1989.       {
  1990.         strpool [ poolptr ] = 46 ; 
  1991.         incr ( poolptr ) ; 
  1992.       } 
  1993.       shownodelist ( mem [ p + 5 ] .hh .v.RH ) ; 
  1994.       decr ( poolptr ) ; 
  1995.     } 
  1996.       } 
  1997.       break ; 
  1998.     case 2 : 
  1999.       {
  2000.     printesc ( 197 ) ; 
  2001.     printruledimen ( mem [ p + 3 ] .cint ) ; 
  2002.     printchar ( 43 ) ; 
  2003.     printruledimen ( mem [ p + 2 ] .cint ) ; 
  2004.     print ( 189 ) ; 
  2005.     printruledimen ( mem [ p + 1 ] .cint ) ; 
  2006.       } 
  2007.       break ; 
  2008.     case 3 : 
  2009.       {
  2010.     printesc ( 198 ) ; 
  2011.     printint ( mem [ p ] .hh.b1 ) ; 
  2012.     print ( 199 ) ; 
  2013.     printscaled ( mem [ p + 3 ] .cint ) ; 
  2014.     print ( 200 ) ; 
  2015.     printspec ( mem [ p + 4 ] .hh .v.RH , 0 ) ; 
  2016.     printchar ( 44 ) ; 
  2017.     printscaled ( mem [ p + 2 ] .cint ) ; 
  2018.     print ( 201 ) ; 
  2019.     printint ( mem [ p + 1 ] .cint ) ; 
  2020.     {
  2021.       {
  2022.         strpool [ poolptr ] = 46 ; 
  2023.         incr ( poolptr ) ; 
  2024.       } 
  2025.       shownodelist ( mem [ p + 4 ] .hh .v.LH ) ; 
  2026.       decr ( poolptr ) ; 
  2027.     } 
  2028.       } 
  2029.       break ; 
  2030.     case 8 : 
  2031.       switch ( mem [ p ] .hh.b1 ) 
  2032.       {case 0 : 
  2033.     {
  2034.       printwritewhatsit ( 1129 , p ) ; 
  2035.       printchar ( 61 ) ; 
  2036.       printfilename ( mem [ p + 1 ] .hh .v.RH , mem [ p + 2 ] .hh .v.LH , 
  2037.       mem [ p + 2 ] .hh .v.RH ) ; 
  2038.     } 
  2039.     break ; 
  2040.       case 1 : 
  2041.     {
  2042.       printwritewhatsit ( 452 , p ) ; 
  2043.       printmark ( mem [ p + 1 ] .hh .v.RH ) ; 
  2044.     } 
  2045.     break ; 
  2046.       case 2 : 
  2047.     printwritewhatsit ( 1130 , p ) ; 
  2048.     break ; 
  2049.       case 3 : 
  2050.     {
  2051.       printesc ( 1131 ) ; 
  2052.       printmark ( mem [ p + 1 ] .hh .v.RH ) ; 
  2053.     } 
  2054.     break ; 
  2055.     default: 
  2056.     print ( 1135 ) ; 
  2057.     break ; 
  2058.       } 
  2059.       break ; 
  2060.     case 10 : 
  2061.       if ( mem [ p ] .hh.b1 >= 100 ) 
  2062.       {
  2063.     printesc ( 206 ) ; 
  2064.     if ( mem [ p ] .hh.b1 == 101 ) 
  2065.     printchar ( 99 ) ; 
  2066.     else if ( mem [ p ] .hh.b1 == 102 ) 
  2067.     printchar ( 120 ) ; 
  2068.     print ( 207 ) ; 
  2069.     printspec ( mem [ p + 1 ] .hh .v.LH , 0 ) ; 
  2070.     {
  2071.       {
  2072.         strpool [ poolptr ] = 46 ; 
  2073.         incr ( poolptr ) ; 
  2074.       } 
  2075.       shownodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  2076.       decr ( poolptr ) ; 
  2077.     } 
  2078.       } 
  2079.       else {
  2080.       
  2081.     printesc ( 202 ) ; 
  2082.     if ( mem [ p ] .hh.b1 != 0 ) 
  2083.     {
  2084.       printchar ( 40 ) ; 
  2085.       if ( mem [ p ] .hh.b1 < 98 ) 
  2086.       printskipparam ( mem [ p ] .hh.b1 - 1 ) ; 
  2087.       else if ( mem [ p ] .hh.b1 == 98 ) 
  2088.       printesc ( 203 ) ; 
  2089.       else printesc ( 204 ) ; 
  2090.       printchar ( 41 ) ; 
  2091.     } 
  2092.     if ( mem [ p ] .hh.b1 != 98 ) 
  2093.     {
  2094.       printchar ( 32 ) ; 
  2095.       if ( mem [ p ] .hh.b1 < 98 ) 
  2096.       printspec ( mem [ p + 1 ] .hh .v.LH , 0 ) ; 
  2097.       else printspec ( mem [ p + 1 ] .hh .v.LH , 205 ) ; 
  2098.     } 
  2099.       } 
  2100.       break ; 
  2101.     case 11 : 
  2102.       if ( mem [ p ] .hh.b1 != 99 ) 
  2103.       {
  2104.     printesc ( 208 ) ; 
  2105.     if ( mem [ p ] .hh.b1 != 0 ) 
  2106.     printchar ( 32 ) ; 
  2107.     printscaled ( mem [ p + 1 ] .cint ) ; 
  2108.     if ( mem [ p ] .hh.b1 == 2 ) 
  2109.     print ( 209 ) ; 
  2110.       } 
  2111.       else {
  2112.       
  2113.     printesc ( 210 ) ; 
  2114.     printscaled ( mem [ p + 1 ] .cint ) ; 
  2115.     print ( 205 ) ; 
  2116.       } 
  2117.       break ; 
  2118.     case 9 : 
  2119.       {
  2120.     printesc ( 211 ) ; 
  2121.     if ( mem [ p ] .hh.b1 == 0 ) 
  2122.     print ( 212 ) ; 
  2123.     else print ( 213 ) ; 
  2124.     if ( mem [ p + 1 ] .cint != 0 ) 
  2125.     {
  2126.       print ( 214 ) ; 
  2127.       printscaled ( mem [ p + 1 ] .cint ) ; 
  2128.     } 
  2129.       } 
  2130.       break ; 
  2131.     case 6 : 
  2132.       {
  2133.     printfontandchar ( p + 1 ) ; 
  2134.     print ( 215 ) ; 
  2135.     fontinshortdisplay = mem [ p + 1 ] .hh.b0 ; 
  2136.     shortdisplay ( mem [ p + 1 ] .hh .v.RH ) ; 
  2137.     printchar ( 41 ) ; 
  2138.       } 
  2139.       break ; 
  2140.     case 12 : 
  2141.       {
  2142.     printesc ( 216 ) ; 
  2143.     printint ( mem [ p + 1 ] .cint ) ; 
  2144.       } 
  2145.       break ; 
  2146.     case 7 : 
  2147.       {
  2148.     printesc ( 217 ) ; 
  2149.     if ( mem [ p ] .hh.b1 > 0 ) 
  2150.     {
  2151.       print ( 218 ) ; 
  2152.       printint ( mem [ p ] .hh.b1 ) ; 
  2153.     } 
  2154.     {
  2155.       {
  2156.         strpool [ poolptr ] = 46 ; 
  2157.         incr ( poolptr ) ; 
  2158.       } 
  2159.       shownodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  2160.       decr ( poolptr ) ; 
  2161.     } 
  2162.     {
  2163.       strpool [ poolptr ] = 124 ; 
  2164.       incr ( poolptr ) ; 
  2165.     } 
  2166.     shownodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  2167.     decr ( poolptr ) ; 
  2168.       } 
  2169.       break ; 
  2170.     case 4 : 
  2171.       {
  2172.     printesc ( 219 ) ; 
  2173.     printmark ( mem [ p + 1 ] .cint ) ; 
  2174.       } 
  2175.       break ; 
  2176.     case 5 : 
  2177.       {
  2178.     printesc ( 220 ) ; 
  2179.     {
  2180.       {
  2181.         strpool [ poolptr ] = 46 ; 
  2182.         incr ( poolptr ) ; 
  2183.       } 
  2184.       shownodelist ( mem [ p + 1 ] .cint ) ; 
  2185.       decr ( poolptr ) ; 
  2186.     } 
  2187.       } 
  2188.       break ; 
  2189.     case 14 : 
  2190.       printstyle ( mem [ p ] .hh.b1 ) ; 
  2191.       break ; 
  2192.     case 15 : 
  2193.       {
  2194.     printesc ( 384 ) ; 
  2195.     {
  2196.       strpool [ poolptr ] = 68 ; 
  2197.       incr ( poolptr ) ; 
  2198.     } 
  2199.     shownodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  2200.     decr ( poolptr ) ; 
  2201.     {
  2202.       strpool [ poolptr ] = 84 ; 
  2203.       incr ( poolptr ) ; 
  2204.     } 
  2205.     shownodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  2206.     decr ( poolptr ) ; 
  2207.     {
  2208.       strpool [ poolptr ] = 83 ; 
  2209.       incr ( poolptr ) ; 
  2210.     } 
  2211.     shownodelist ( mem [ p + 2 ] .hh .v.LH ) ; 
  2212.     decr ( poolptr ) ; 
  2213.     {
  2214.       strpool [ poolptr ] = 115 ; 
  2215.       incr ( poolptr ) ; 
  2216.     } 
  2217.     shownodelist ( mem [ p + 2 ] .hh .v.RH ) ; 
  2218.     decr ( poolptr ) ; 
  2219.       } 
  2220.       break ; 
  2221.     case 16 : 
  2222.     case 17 : 
  2223.     case 18 : 
  2224.     case 19 : 
  2225.     case 20 : 
  2226.     case 21 : 
  2227.     case 22 : 
  2228.     case 23 : 
  2229.     case 24 : 
  2230.     case 27 : 
  2231.     case 26 : 
  2232.     case 29 : 
  2233.     case 28 : 
  2234.     case 30 : 
  2235.     case 31 : 
  2236.       {
  2237.     switch ( mem [ p ] .hh.b0 ) 
  2238.     {case 16 : 
  2239.       printesc ( 719 ) ; 
  2240.       break ; 
  2241.     case 17 : 
  2242.       printesc ( 720 ) ; 
  2243.       break ; 
  2244.     case 18 : 
  2245.       printesc ( 721 ) ; 
  2246.       break ; 
  2247.     case 19 : 
  2248.       printesc ( 722 ) ; 
  2249.       break ; 
  2250.     case 20 : 
  2251.       printesc ( 723 ) ; 
  2252.       break ; 
  2253.     case 21 : 
  2254.       printesc ( 724 ) ; 
  2255.       break ; 
  2256.     case 22 : 
  2257.       printesc ( 725 ) ; 
  2258.       break ; 
  2259.     case 23 : 
  2260.       printesc ( 726 ) ; 
  2261.       break ; 
  2262.     case 27 : 
  2263.       printesc ( 727 ) ; 
  2264.       break ; 
  2265.     case 26 : 
  2266.       printesc ( 728 ) ; 
  2267.       break ; 
  2268.     case 29 : 
  2269.       printesc ( 397 ) ; 
  2270.       break ; 
  2271.     case 24 : 
  2272.       {
  2273.         printesc ( 391 ) ; 
  2274.         printdelimiter ( p + 4 ) ; 
  2275.       } 
  2276.       break ; 
  2277.     case 28 : 
  2278.       {
  2279.         printesc ( 367 ) ; 
  2280.         printfamandchar ( p + 4 ) ; 
  2281.       } 
  2282.       break ; 
  2283.     case 30 : 
  2284.       {
  2285.         printesc ( 729 ) ; 
  2286.         printdelimiter ( p + 1 ) ; 
  2287.       } 
  2288.       break ; 
  2289.     case 31 : 
  2290.       {
  2291.         printesc ( 730 ) ; 
  2292.         printdelimiter ( p + 1 ) ; 
  2293.       } 
  2294.       break ; 
  2295.     } 
  2296.     if ( mem [ p ] .hh.b1 != 0 ) 
  2297.     if ( mem [ p ] .hh.b1 == 1 ) 
  2298.     printesc ( 731 ) ; 
  2299.     else printesc ( 732 ) ; 
  2300.     if ( mem [ p ] .hh.b0 < 30 ) 
  2301.     printsubsidiarydata ( p + 1 , 46 ) ; 
  2302.     printsubsidiarydata ( p + 2 , 94 ) ; 
  2303.     printsubsidiarydata ( p + 3 , 95 ) ; 
  2304.       } 
  2305.       break ; 
  2306.     case 25 : 
  2307.       {
  2308.     printesc ( 733 ) ; 
  2309.     if ( mem [ p + 1 ] .cint == 1073741824L ) 
  2310.     print ( 734 ) ; 
  2311.     else printscaled ( mem [ p + 1 ] .cint ) ; 
  2312.     if ( ( mem [ p + 4 ] .qqqq .b0 != 0 ) || ( mem [ p + 4 ] .qqqq .b1 != 
  2313.     0 ) || ( mem [ p + 4 ] .qqqq .b2 != 0 ) || ( mem [ p + 4 ] .qqqq .b3 
  2314.     != 0 ) ) 
  2315.     {
  2316.       print ( 735 ) ; 
  2317.       printdelimiter ( p + 4 ) ; 
  2318.     } 
  2319.     if ( ( mem [ p + 5 ] .qqqq .b0 != 0 ) || ( mem [ p + 5 ] .qqqq .b1 != 
  2320.     0 ) || ( mem [ p + 5 ] .qqqq .b2 != 0 ) || ( mem [ p + 5 ] .qqqq .b3 
  2321.     != 0 ) ) 
  2322.     {
  2323.       print ( 736 ) ; 
  2324.       printdelimiter ( p + 5 ) ; 
  2325.     } 
  2326.     printsubsidiarydata ( p + 2 , 92 ) ; 
  2327.     printsubsidiarydata ( p + 3 , 47 ) ; 
  2328.       } 
  2329.       break ; 
  2330.       default: 
  2331.       print ( 186 ) ; 
  2332.       break ; 
  2333.     } 
  2334.     p = mem [ p ] .hh .v.RH ; 
  2335.   } 
  2336. } 
  2337.